home *** CD-ROM | disk | FTP | other *** search
/ Disc to the Future 2 / Disc to the Future Part II Programmer's Reference (Wayzata Technology)(6013)(1992).bin / MAC / THINKC / 4_0 / 3D_GRAPH / G3D_EVAL.C < prev    next >
Text File  |  1989-08-28  |  4KB  |  228 lines
  1. /*
  2.     Copyright '89    Christopher Moll
  3.     all rights reserved
  4. */
  5.  
  6.  
  7. #include    "graph3D.h"
  8. #include    <math.h>
  9.  
  10. extern    Boolean    useMainFunc;
  11.  
  12. extern    Real        *funcResults;
  13. extern    Vector        *scalVectResults;
  14. extern    Point        *graphPoints;    /* same elements as funcResults */
  15.  
  16. extern    Boolean        invldFormla;
  17.  
  18. extern    Boolean        functCurrent;
  19. extern    Boolean        vectrsCurrent;
  20.  
  21. extern    Boolean        noRedrawGrph;
  22.  
  23. extern    Vector        maxVect, minVect;
  24. extern    Real        rotMatrx[3][3];
  25.  
  26. extern    Boolean        inMultiFndr;
  27.  
  28. Real    startR, startT;
  29. Real    endR, endT;
  30. Real    deltaR, deltaT;
  31. int        numR, numT;
  32.  
  33.  
  34. EvalCylindFunct()
  35. {
  36.     Boolean    AllocateCylndPts();
  37.  
  38.     invldFormla = FALSE;
  39.     noRedrawGrph = TRUE;
  40.  
  41.     LoadFunction();
  42.  
  43.     if (invldFormla)    /* already gave warning message */
  44.         return;
  45.  
  46.     GetSpecDCont();
  47.  
  48.     deltaR = (endR - startR) / (numR - 1);
  49.     deltaT = (endT - startT) / (numT - 1);
  50.  
  51.     if (NOT(AllocateCylndPts()))
  52.         return;
  53.  
  54.     StoreCylindFunct();
  55.  
  56.     vectrsCurrent = FALSE;
  57.     functCurrent = TRUE;
  58.     noRedrawGrph = FALSE;
  59. }
  60.  
  61. static
  62. Boolean
  63. AllocateCylndPts()
  64. {
  65.     if (funcResults NEQ NIL)
  66.         free(funcResults);
  67.     if (scalVectResults NEQ NIL)
  68.         free(scalVectResults);
  69.     if (graphPoints NEQ NIL)
  70.         free(graphPoints);
  71.     funcResults = (Real *)NewPtr((long)sizeof(Real) * (long)numR * numT);
  72.     if (MemErr)
  73.         return(FALSE);
  74.     scalVectResults = (Vector *)NewPtr((long)sizeof(Vector) * (long)numR * numT);
  75.     if (MemErr)
  76.         return(FALSE);
  77.     graphPoints = (Point *)NewPtr((long)sizeof(Point) * (long)numR * numT);
  78.     if (MemErr)
  79.         return(FALSE);
  80.  
  81.     return(TRUE);
  82. }
  83.  
  84. static
  85. StoreCylindFunct()
  86. {
  87.     register    int    rCnt, tCnt;
  88.     Real        currR, currT;
  89.     Real        maxFunc, minFunc, funcVal;
  90.     Real        rAtMax, tAtMax;
  91.     Real        rAtMin, tAtMin;
  92.     Real        TheFunction();
  93.     Boolean        CmndPeriod();
  94.     
  95.     ShowMeter((long)numR * numT);
  96.  
  97.     useMainFunc = TRUE;
  98.     funcVal = TheFunction(startR, startT);
  99.     maxFunc = funcVal;
  100.     minFunc = funcVal;
  101.     rAtMax = startR;
  102.     tAtMax = startT;
  103.     rAtMin = startR;
  104.     tAtMin = startT;
  105.  
  106.     currR = startR;
  107.     for (rCnt = 0; rCnt < numR; rCnt++)
  108.     {
  109.         currT = startT;
  110.         for (tCnt = 0; tCnt < numT; tCnt++)
  111.         {
  112.             funcVal = TheFunction(currR, currT);
  113.             DisplayMeter();
  114.             funcResults[rCnt * numT + tCnt] = funcVal;
  115.             if (funcVal > maxFunc)
  116.             {
  117.                 maxFunc = funcVal;
  118.                 rAtMax = currR;
  119.                 tAtMax = currT;
  120.             }
  121.             else if (funcVal < minFunc)
  122.             {
  123.                 minFunc = funcVal;
  124.                 rAtMin = currR;
  125.                 tAtMin = currT;
  126.             }
  127.             currT += deltaT;
  128.         }
  129.         if (CmndPeriod())
  130.             break;  /* for */
  131.         currR += deltaR;
  132.     }
  133.  
  134. done:
  135.     maxVect.x = rAtMax * cos(tAtMax);
  136.     maxVect.y = rAtMax * sin(tAtMax);
  137.     maxVect.z = maxFunc;
  138.  
  139.     minVect.x = rAtMin * cos(tAtMin);
  140.     minVect.y = rAtMin * sin(tAtMin);
  141.     minVect.z = minFunc;
  142.  
  143.     RemoveMeter();
  144. }
  145.  
  146.  
  147.  
  148. SetCylindVectrs()
  149. {
  150. register    int    rCnt, tCnt;
  151. register    long    offSet;
  152.     Real        ImposLimits();
  153. register    Real        rValue, tValue;
  154. register    Vector        *scalePtr;
  155.     Real    SdeltaR;
  156. register    Real    SdeltaT;
  157.     Vector    pntVect;
  158.  
  159.     SdeltaR = deltaR;
  160.     SdeltaT = deltaT;
  161.  
  162.     scalePtr = scalVectResults;
  163.  
  164.     rValue = startR;
  165.  
  166.     for (rCnt = 0; rCnt < numR; rCnt++)
  167.     {
  168.         tValue = startT;
  169.         for (tCnt = 0; tCnt < numT; tCnt++)
  170.         {
  171.             offSet = (long)rCnt * (long)numT + tCnt;
  172.             pntVect.x = rValue * cos(tValue);
  173.             pntVect.y = rValue * sin(tValue);
  174.             pntVect.z = (ImposLimits(funcResults[offSet]));
  175.             MatrxMul(rotMatrx, &pntVect, scalePtr++);
  176.             tValue += SdeltaT;
  177.         }
  178.         rValue += SdeltaR;
  179.     }
  180.  
  181.     vectrsCurrent = TRUE;
  182. }
  183.  
  184.  
  185.  
  186. /*--------------------------------------------------------------------------------*/
  187.  
  188.  
  189.  
  190.  
  191.  
  192.  
  193. __SetCylindVectrs()
  194. {
  195. register    int    rCnt, tCnt;
  196. register    long    offSet;
  197.     Real        ImposLimits();
  198. register    Real        rValue, tValue;
  199. register    Vector        *scalePtr;
  200.     Real    SdeltaR;
  201. register    Real    SdeltaT;
  202.     Vector    pntVect;
  203.  
  204.     SdeltaR = deltaR;
  205.     SdeltaT = deltaT;
  206.  
  207.     scalePtr = scalVectResults;
  208.  
  209.     rValue = startR;
  210.  
  211.     for (rCnt = 0; rCnt < numR; rCnt++)
  212.     {
  213.         tValue = startT;
  214.         for (tCnt = 0; tCnt < numT; tCnt++)
  215.         {
  216.             offSet = (long)rCnt * (long)numT + tCnt;
  217.             pntVect.x = ImposLimits(rValue*tValue);
  218.             pntVect.y = ImposLimits(sin(tValue)+cos(rValue));
  219.             pntVect.z = ImposLimits(cos(rValue));
  220.             MatrxMul(rotMatrx, &pntVect, scalePtr++);
  221.             tValue += SdeltaT;
  222.         }
  223.         rValue += SdeltaR;
  224.     }
  225.  
  226.     vectrsCurrent = TRUE;
  227. }
  228.